home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / m2posx10.zoo / m2posix.10 / src / memblk.dpp < prev    next >
Encoding:
Modula Definition  |  1993-10-06  |  5.5 KB  |  109 lines
  1. DEFINITION MODULE MEMBLK;
  2. __DEF_SWITCHES__
  3. #ifdef HM2
  4. #ifdef __LONG_WHOLE__
  5. (*$!i+: Modul muss mit $i- uebersetzt werden! *)
  6. (*$!w+: Modul muss mit $w- uebersetzt werden! *)
  7. #else
  8. (*$!i-: Modul muss mit $i+ uebersetzt werden! *)
  9. (*$!w-: Modul muss mit $w+ uebersetzt werden! *)
  10. #endif
  11. #endif
  12. (*****************************************************************************)
  13. (* (effiziente) Operationen auf typenlosen Speicherbereichen.                *)
  14. (* Dies sind Ansi-C-Funktionen, bis auf "memswap()" und "*alloc()".          *)
  15. (* "memmove()" und "memset()" liefern allerdings nicht die Adresse des Ziel- *)
  16. (* strings als Funktionswert.                                                *)
  17. (* --------------------------------------------------------------------------*)
  18. (* 28-Sep-93, Holger Kleinschmidt                                            *)
  19. (*****************************************************************************)
  20.  
  21. FROM SYSTEM IMPORT
  22. (* TYPE *) ADDRESS;
  23.  
  24. FROM types IMPORT
  25. (* TYPE *) sizeT;
  26.  
  27. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  28.  
  29.  PROCEDURE memmove ((* EIN/ -- *) dst : ADDRESS;
  30.                     (* EIN/ -- *) src : ADDRESS;
  31.                     (* EIN/ -- *) len : sizeT   );
  32.  
  33. (*--------------------------------------------------------------------------
  34.  | Kopiert <len> Bytes von <src> nach <dst>. Die Bereiche duerfen sich      |
  35.  | ueberlappen. Wenn beide Adressen gerade oder ungerade sind, wird beson-  |
  36.  | ders schnell kopiert.                                                    |
  37.   --------------------------------------------------------------------------*)
  38.  
  39.  PROCEDURE memset ((* EIN/ -- *) dst : ADDRESS;
  40.                    (* EIN/ -- *) val : CARDINAL;
  41.                    (* EIN/ -- *) len : sizeT    );
  42.  
  43. (*--------------------------------------------------------------------------
  44.  | Setzt <len> Bytes ab Adresse <dst> auf <val>. Der Wert in <val> wird     |
  45.  | modulo 256 genommen, d.h. es zaehlt nur das untere Byte.                 |
  46.   --------------------------------------------------------------------------*)
  47.  
  48.  PROCEDURE memchr ((* EIN/ -- *) src : ADDRESS;
  49.                    (* EIN/ -- *) val : CARDINAL;
  50.                    (* EIN/ -- *) len : sizeT    ): ADDRESS;
  51.  
  52. (*--------------------------------------------------------------------------
  53.  | Liefert einen Zeiger auf das erste Byte mit dem Wert <val> modulo 256,   |
  54.  | das in den ersten <len> Bytes ab <src> vorkommt, oder NULL, falls ein    |
  55.  | solcher Wert nicht vorkommt.                                             |
  56.   --------------------------------------------------------------------------*)
  57.  
  58.  
  59.  PROCEDURE memcmp ((* EIN/ -- *) blk1 : ADDRESS;
  60.                    (* EIN/ -- *) blk2 : ADDRESS;
  61.                    (* EIN/ -- *) len  : sizeT   ): INTEGER;
  62.  
  63. (*--------------------------------------------------------------------------
  64.  | Vergleicht <len> Bytes ab den Adressen <blk1> und <blk2> miteinander.    |
  65.  | Falls alle Bytes gleich sind, wird Null zurueckgeliefert, falls ein Byte |
  66.  | in <blk>^ kleiner als in <blk2>^ ist, wird ein Wert kleiner Null zurueck-|
  67.  | geliefert, falls ein Byte gresser ist, wird ein Wert groesser Null zu-   |
  68.  | rueckgeliefert.                                                          |
  69.   --------------------------------------------------------------------------*)
  70.  
  71.  
  72. (* Nicht Ansi-C: *)
  73.  PROCEDURE memswap ((* EIN/ -- *) blk1 : ADDRESS;
  74.                     (* EIN/ -- *) blk2 : ADDRESS;
  75.                     (* EIN/ -- *) len  : sizeT   );
  76.  
  77. (*--------------------------------------------------------------------------
  78.  | Tauscht <len> Bytes ab Adresse <blk1> bzw. <blk2> gegeneinander aus.     |
  79.  | Die Speicherbereiche duerfen sich nicht ueberlappen.                     |
  80.   --------------------------------------------------------------------------*)
  81.  
  82. (* Nicht Ansi-C: *)
  83.  PROCEDURE memalloc ((* EIN/ -- *)     size : sizeT;
  84.                      (* -- /AUS *) VAR old  : ADDRESS;
  85.                      (* -- /AUS *) VAR adr  : ADDRESS );
  86.  
  87.  PROCEDURE memdealloc ((* EIN/ -- *) old : ADDRESS );
  88.  
  89. (*--------------------------------------------------------------------------
  90.  | Mit "memalloc()" wird Speicherplatz auf dem Stack reserviert, der durch  |
  91.  | "memdealloc()" wieder freigegeben wird.                                  |
  92.  | <old> ist der Wert des Stackpointers vor Aufruf der Funktion. Dieser Wert|
  93.  | wird bei "memdealloc()" angegeben, um den Stackpointer wieder zurueckzu- |
  94.  | setzen. Wenn mehrere Male "memalloc()" hintereinander aufgerufen wird,   |
  95.  | reicht es, sich den Wert des Stackpointers vor dem ersten der Aufrufe zu |
  96.  | merken, und nur einmal "memdealloc()" mit diesem Wert aufzurufen.        |
  97.  | <adr> ist der neue Wert des Stackpointers und dient gleichzeitig als     |
  98.  | Anfangsadresse des freien Speichers, der <size> Bytes Platz bietet.      |
  99.  | "memalloc()" entspricht ungefaehr dem ``C''-alloca, nur wird zusaetzlich |
  100.  | der alte Stackpointer zurueckgeliefert. "memdealloc()" entspricht dem    |
  101.  | ``C''-setstack. Die Aufteilung in zwei Funktionen gegenueber der alleini-|
  102.  | gen Verwendung von 'alloca' in ``C'' ist notwendig, da die meisten M2-   |
  103.  | Compiler ihre Register NACH dem LINK retten und VOR dem UNLK zurueck-    |
  104.  | schreiben, weshalb der Stackpointer am Ende der Funktion den Wert nach   |
  105.  | dem Registerretten haben muss.                                           |
  106.   --------------------------------------------------------------------------*)
  107.  
  108. END MEMBLK.
  109.